﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents a homogeneous 3D transformation matrix.</summary>
	// Token: 0x02000041 RID: 65
	[Serializable]
	public class HHomMat3D : HData, ISerializable, ICloneable
	{
		// Token: 0x06000635 RID: 1589 RVA: 0x0000B2B0 File Offset: 0x000094B0
		public HHomMat3D(HTuple tuple) : base(tuple)
		{
		}

		// Token: 0x06000636 RID: 1590 RVA: 0x0000B2B9 File Offset: 0x000094B9
		internal HHomMat3D(HData data) : base(data)
		{
		}

		// Token: 0x06000637 RID: 1591 RVA: 0x00024FA0 File Offset: 0x000231A0
		internal static int LoadNew(IntPtr proc, int parIndex, HTupleType type, int err, out HHomMat3D obj)
		{
			HTuple t;
			err = HTuple.LoadNew(proc, parIndex, err, out t);
			obj = new HHomMat3D(new HData(t));
			return err;
		}

		// Token: 0x06000638 RID: 1592 RVA: 0x00024FC8 File Offset: 0x000231C8
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HHomMat3D obj)
		{
			return HHomMat3D.LoadNew(proc, parIndex, HTupleType.MIXED, err, out obj);
		}

		// Token: 0x06000639 RID: 1593 RVA: 0x00024FD4 File Offset: 0x000231D4
		internal static HHomMat3D[] SplitArray(HTuple data)
		{
			int num = data.Length / 12;
			HHomMat3D[] array = new HHomMat3D[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = new HHomMat3D(new HData(data.TupleSelectRange(i * 12, (i + 1) * 12 - 1)));
			}
			return array;
		}

		/// <summary>
		///   Generate the homogeneous transformation matrix of the identical 3D transformation.
		///   Modified instance represents: Transformation matrix.
		/// </summary>
		// Token: 0x0600063A RID: 1594 RVA: 0x00025028 File Offset: 0x00023228
		public HHomMat3D()
		{
			IntPtr proc = HalconAPI.PreCall(253);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x0600063B RID: 1595 RVA: 0x0002506C File Offset: 0x0002326C
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeHomMat3d();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x0600063C RID: 1596 RVA: 0x000250A4 File Offset: 0x000232A4
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HHomMat3D(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeHomMat3d(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x0600063D RID: 1597 RVA: 0x000250E4 File Offset: 0x000232E4
		public void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeHomMat3d();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x0600063E RID: 1598 RVA: 0x000250F8 File Offset: 0x000232F8
		public static HHomMat3D Deserialize(Stream stream)
		{
			HHomMat3D hhomMat3D = new HHomMat3D();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hhomMat3D.DeserializeHomMat3d(hserializedItem);
			hserializedItem.Dispose();
			return hhomMat3D;
		}

		// Token: 0x0600063F RID: 1599 RVA: 0x0002511E File Offset: 0x0002331E
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000640 RID: 1600 RVA: 0x00025128 File Offset: 0x00023328
		public HHomMat3D Clone()
		{
			HSerializedItem hserializedItem = this.SerializeHomMat3d();
			HHomMat3D hhomMat3D = new HHomMat3D();
			hhomMat3D.DeserializeHomMat3d(hserializedItem);
			hserializedItem.Dispose();
			return hhomMat3D;
		}

		/// <summary>
		///   Deserialize a serialized homogeneous 3D transformation matrix.
		///   Modified instance represents: Transformation matrix.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06000641 RID: 1601 RVA: 0x00025150 File Offset: 0x00023350
		public void DeserializeHomMat3d(HSerializedItem serializedItemHandle)
		{
			IntPtr proc = HalconAPI.PreCall(233);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a homogeneous 3D transformation matrix.
		///   Instance represents: Transformation matrix.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06000642 RID: 1602 RVA: 0x0002519C File Offset: 0x0002339C
		public HSerializedItem SerializeHomMat3d()
		{
			IntPtr proc = HalconAPI.PreCall(234);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a homogeneous 3D point using a projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="pw">Input point (w coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qz">Output point (z coordinate).</param>
		/// <param name="qw">Output point (w coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x06000643 RID: 1603 RVA: 0x000251EC File Offset: 0x000233EC
		public HTuple ProjectiveTransHomPoint3d(HTuple px, HTuple py, HTuple pz, HTuple pw, out HTuple qy, out HTuple qz, out HTuple qw)
		{
			IntPtr proc = HalconAPI.PreCall(239);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pz);
			HalconAPI.Store(proc, 4, pw);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HalconAPI.UnpinTuple(pw);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out qz);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out qw);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a homogeneous 3D point using a projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="pw">Input point (w coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qz">Output point (z coordinate).</param>
		/// <param name="qw">Output point (w coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x06000644 RID: 1604 RVA: 0x000252B4 File Offset: 0x000234B4
		public double ProjectiveTransHomPoint3d(double px, double py, double pz, double pw, out double qy, out double qz, out double qw)
		{
			IntPtr proc = HalconAPI.PreCall(239);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, pz);
			HalconAPI.StoreD(proc, 4, pw);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			num = HalconAPI.LoadD(proc, 2, num, out qz);
			num = HalconAPI.LoadD(proc, 3, num, out qw);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a 3D point using a projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qz">Output point (z coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x06000645 RID: 1605 RVA: 0x0002535C File Offset: 0x0002355C
		public HTuple ProjectiveTransPoint3d(HTuple px, HTuple py, HTuple pz, out HTuple qy, out HTuple qz)
		{
			IntPtr proc = HalconAPI.PreCall(240);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pz);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out qz);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a 3D point using a projective transformation matrix.
		///   Instance represents: Homogeneous projective transformation matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qz">Output point (z coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x06000646 RID: 1606 RVA: 0x00025400 File Offset: 0x00023600
		public double ProjectiveTransPoint3d(double px, double py, double pz, out double qy, out double qz)
		{
			IntPtr proc = HalconAPI.PreCall(240);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, pz);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			num = HalconAPI.LoadD(proc, 2, num, out qz);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 3D transformation to points.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">Input point(s) (x coordinate). Default: 64</param>
		/// <param name="py">Input point(s) (y coordinate). Default: 64</param>
		/// <param name="pz">Input point(s) (z coordinate). Default: 64</param>
		/// <param name="qy">Output point(s) (y coordinate).</param>
		/// <param name="qz">Output point(s) (z coordinate).</param>
		/// <returns>Output point(s) (x coordinate).</returns>
		// Token: 0x06000647 RID: 1607 RVA: 0x0002548C File Offset: 0x0002368C
		public HTuple AffineTransPoint3d(HTuple px, HTuple py, HTuple pz, out HTuple qy, out HTuple qz)
		{
			IntPtr proc = HalconAPI.PreCall(241);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pz);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out qz);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 3D transformation to points.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="px">Input point(s) (x coordinate). Default: 64</param>
		/// <param name="py">Input point(s) (y coordinate). Default: 64</param>
		/// <param name="pz">Input point(s) (z coordinate). Default: 64</param>
		/// <param name="qy">Output point(s) (y coordinate).</param>
		/// <param name="qz">Output point(s) (z coordinate).</param>
		/// <returns>Output point(s) (x coordinate).</returns>
		// Token: 0x06000648 RID: 1608 RVA: 0x00025530 File Offset: 0x00023730
		public double AffineTransPoint3d(double px, double py, double pz, out double qy, out double qz)
		{
			IntPtr proc = HalconAPI.PreCall(241);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, pz);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			num = HalconAPI.LoadD(proc, 2, num, out qz);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Approximate a 3D transformation from point correspondences.
		///   Modified instance represents: Output transformation matrix.
		/// </summary>
		/// <param name="transformationType">Type of the transformation to compute. Default: "rigid"</param>
		/// <param name="px">X coordinates of the original points.</param>
		/// <param name="py">Y coordinates of the original points.</param>
		/// <param name="pz">Z coordinates of the original points.</param>
		/// <param name="qx">X coordinates of the transformed points.</param>
		/// <param name="qy">Y coordinates of the transformed points.</param>
		/// <param name="qz">Z coordinates of the transformed points.</param>
		// Token: 0x06000649 RID: 1609 RVA: 0x000255BC File Offset: 0x000237BC
		public void VectorToHomMat3d(string transformationType, HTuple px, HTuple py, HTuple pz, HTuple qx, HTuple qy, HTuple qz)
		{
			IntPtr proc = HalconAPI.PreCall(242);
			HalconAPI.StoreS(proc, 0, transformationType);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pz);
			HalconAPI.Store(proc, 4, qx);
			HalconAPI.Store(proc, 5, qy);
			HalconAPI.Store(proc, 6, qz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HalconAPI.UnpinTuple(qx);
			HalconAPI.UnpinTuple(qy);
			HalconAPI.UnpinTuple(qz);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the determinant of a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <returns>Determinant of the input matrix.</returns>
		// Token: 0x0600064A RID: 1610 RVA: 0x00025660 File Offset: 0x00023860
		public double HomMat3dDeterminant()
		{
			IntPtr proc = HalconAPI.PreCall(243);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transpose a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600064B RID: 1611 RVA: 0x000256B0 File Offset: 0x000238B0
		public HHomMat3D HomMat3dTranspose()
		{
			IntPtr proc = HalconAPI.PreCall(244);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Invert a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600064C RID: 1612 RVA: 0x00025700 File Offset: 0x00023900
		public HHomMat3D HomMat3dInvert()
		{
			IntPtr proc = HalconAPI.PreCall(245);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Multiply two homogeneous 3D transformation matrices.
		///   Instance represents: Left input transformation matrix.
		/// </summary>
		/// <param name="homMat3DRight">Right input transformation matrix.</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600064D RID: 1613 RVA: 0x00025750 File Offset: 0x00023950
		public HHomMat3D HomMat3dCompose(HHomMat3D homMat3DRight)
		{
			IntPtr proc = HalconAPI.PreCall(246);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, homMat3DRight);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(homMat3DRight);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <param name="axis">Axis, to be rotated around. Default: "x"</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600064E RID: 1614 RVA: 0x000257B8 File Offset: 0x000239B8
		public HHomMat3D HomMat3dRotateLocal(HTuple phi, HTuple axis)
		{
			IntPtr proc = HalconAPI.PreCall(247);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, phi);
			HalconAPI.Store(proc, 2, axis);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(axis);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <param name="axis">Axis, to be rotated around. Default: "x"</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x0600064F RID: 1615 RVA: 0x00025824 File Offset: 0x00023A24
		public HHomMat3D HomMat3dRotateLocal(double phi, string axis)
		{
			IntPtr proc = HalconAPI.PreCall(247);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, phi);
			HalconAPI.StoreS(proc, 2, axis);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <param name="axis">Axis, to be rotated around. Default: "x"</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <param name="pz">Fixed point of the transformation (z coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000650 RID: 1616 RVA: 0x00025884 File Offset: 0x00023A84
		public HHomMat3D HomMat3dRotate(HTuple phi, HTuple axis, HTuple px, HTuple py, HTuple pz)
		{
			IntPtr proc = HalconAPI.PreCall(248);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, phi);
			HalconAPI.Store(proc, 2, axis);
			HalconAPI.Store(proc, 3, px);
			HalconAPI.Store(proc, 4, py);
			HalconAPI.Store(proc, 5, pz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(axis);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rotation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="phi">Rotation angle. Default: 0.78</param>
		/// <param name="axis">Axis, to be rotated around. Default: "x"</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <param name="pz">Fixed point of the transformation (z coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000651 RID: 1617 RVA: 0x0002591C File Offset: 0x00023B1C
		public HHomMat3D HomMat3dRotate(double phi, string axis, double px, double py, double pz)
		{
			IntPtr proc = HalconAPI.PreCall(248);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, phi);
			HalconAPI.StoreS(proc, 2, axis);
			HalconAPI.StoreD(proc, 3, px);
			HalconAPI.StoreD(proc, 4, py);
			HalconAPI.StoreD(proc, 5, pz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <param name="sz">Scale factor along the z-axis. Default: 2</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000652 RID: 1618 RVA: 0x00025994 File Offset: 0x00023B94
		public HHomMat3D HomMat3dScaleLocal(HTuple sx, HTuple sy, HTuple sz)
		{
			IntPtr proc = HalconAPI.PreCall(249);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sx);
			HalconAPI.Store(proc, 2, sy);
			HalconAPI.Store(proc, 3, sz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(sx);
			HalconAPI.UnpinTuple(sy);
			HalconAPI.UnpinTuple(sz);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <param name="sz">Scale factor along the z-axis. Default: 2</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000653 RID: 1619 RVA: 0x00025A0C File Offset: 0x00023C0C
		public HHomMat3D HomMat3dScaleLocal(double sx, double sy, double sz)
		{
			IntPtr proc = HalconAPI.PreCall(249);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, sx);
			HalconAPI.StoreD(proc, 2, sy);
			HalconAPI.StoreD(proc, 3, sz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <param name="sz">Scale factor along the z-axis. Default: 2</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <param name="pz">Fixed point of the transformation (z coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000654 RID: 1620 RVA: 0x00025A74 File Offset: 0x00023C74
		public HHomMat3D HomMat3dScale(HTuple sx, HTuple sy, HTuple sz, HTuple px, HTuple py, HTuple pz)
		{
			IntPtr proc = HalconAPI.PreCall(250);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sx);
			HalconAPI.Store(proc, 2, sy);
			HalconAPI.Store(proc, 3, sz);
			HalconAPI.Store(proc, 4, px);
			HalconAPI.Store(proc, 5, py);
			HalconAPI.Store(proc, 6, pz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(sx);
			HalconAPI.UnpinTuple(sy);
			HalconAPI.UnpinTuple(sz);
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a scaling to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="sx">Scale factor along the x-axis. Default: 2</param>
		/// <param name="sy">Scale factor along the y-axis. Default: 2</param>
		/// <param name="sz">Scale factor along the z-axis. Default: 2</param>
		/// <param name="px">Fixed point of the transformation (x coordinate). Default: 0</param>
		/// <param name="py">Fixed point of the transformation (y coordinate). Default: 0</param>
		/// <param name="pz">Fixed point of the transformation (z coordinate). Default: 0</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000655 RID: 1621 RVA: 0x00025B1C File Offset: 0x00023D1C
		public HHomMat3D HomMat3dScale(double sx, double sy, double sz, double px, double py, double pz)
		{
			IntPtr proc = HalconAPI.PreCall(250);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, sx);
			HalconAPI.StoreD(proc, 2, sy);
			HalconAPI.StoreD(proc, 3, sz);
			HalconAPI.StoreD(proc, 4, px);
			HalconAPI.StoreD(proc, 5, py);
			HalconAPI.StoreD(proc, 6, pz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <param name="tz">Translation along the z-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000656 RID: 1622 RVA: 0x00025BA0 File Offset: 0x00023DA0
		public HHomMat3D HomMat3dTranslateLocal(HTuple tx, HTuple ty, HTuple tz)
		{
			IntPtr proc = HalconAPI.PreCall(251);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, tx);
			HalconAPI.Store(proc, 2, ty);
			HalconAPI.Store(proc, 3, tz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(tx);
			HalconAPI.UnpinTuple(ty);
			HalconAPI.UnpinTuple(tz);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <param name="tz">Translation along the z-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000657 RID: 1623 RVA: 0x00025C18 File Offset: 0x00023E18
		public HHomMat3D HomMat3dTranslateLocal(double tx, double ty, double tz)
		{
			IntPtr proc = HalconAPI.PreCall(251);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, tx);
			HalconAPI.StoreD(proc, 2, ty);
			HalconAPI.StoreD(proc, 3, tz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <param name="tz">Translation along the z-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000658 RID: 1624 RVA: 0x00025C80 File Offset: 0x00023E80
		public HHomMat3D HomMat3dTranslate(HTuple tx, HTuple ty, HTuple tz)
		{
			IntPtr proc = HalconAPI.PreCall(252);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, tx);
			HalconAPI.Store(proc, 2, ty);
			HalconAPI.Store(proc, 3, tz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(tx);
			HalconAPI.UnpinTuple(ty);
			HalconAPI.UnpinTuple(tz);
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a translation to a homogeneous 3D transformation matrix.
		///   Instance represents: Input transformation matrix.
		/// </summary>
		/// <param name="tx">Translation along the x-axis. Default: 64</param>
		/// <param name="ty">Translation along the y-axis. Default: 64</param>
		/// <param name="tz">Translation along the z-axis. Default: 64</param>
		/// <returns>Output transformation matrix.</returns>
		// Token: 0x06000659 RID: 1625 RVA: 0x00025CF8 File Offset: 0x00023EF8
		public HHomMat3D HomMat3dTranslate(double tx, double ty, double tz)
		{
			IntPtr proc = HalconAPI.PreCall(252);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, tx);
			HalconAPI.StoreD(proc, 2, ty);
			HalconAPI.StoreD(proc, 3, tz);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat3D result;
			num = HHomMat3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Generate the homogeneous transformation matrix of the identical 3D transformation.
		///   Modified instance represents: Transformation matrix.
		/// </summary>
		// Token: 0x0600065A RID: 1626 RVA: 0x00025D60 File Offset: 0x00023F60
		public void HomMat3dIdentity()
		{
			IntPtr proc = HalconAPI.PreCall(253);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Project an affine 3D transformation matrix to a 2D projective transformation matrix.
		///   Instance represents: 3x4 3D transformation matrix.
		/// </summary>
		/// <param name="principalPointRow">Row coordinate of the principal point. Default: 256</param>
		/// <param name="principalPointCol">Column coordinate of the principal point. Default: 256</param>
		/// <param name="focus">Focal length in pixels. Default: 256</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x0600065B RID: 1627 RVA: 0x00025DA0 File Offset: 0x00023FA0
		public HHomMat2D HomMat3dProject(HTuple principalPointRow, HTuple principalPointCol, HTuple focus)
		{
			IntPtr proc = HalconAPI.PreCall(254);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, principalPointRow);
			HalconAPI.Store(proc, 2, principalPointCol);
			HalconAPI.Store(proc, 3, focus);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(principalPointRow);
			HalconAPI.UnpinTuple(principalPointCol);
			HalconAPI.UnpinTuple(focus);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project an affine 3D transformation matrix to a 2D projective transformation matrix.
		///   Instance represents: 3x4 3D transformation matrix.
		/// </summary>
		/// <param name="principalPointRow">Row coordinate of the principal point. Default: 256</param>
		/// <param name="principalPointCol">Column coordinate of the principal point. Default: 256</param>
		/// <param name="focus">Focal length in pixels. Default: 256</param>
		/// <returns>Homogeneous projective transformation matrix.</returns>
		// Token: 0x0600065C RID: 1628 RVA: 0x00025E18 File Offset: 0x00024018
		public HHomMat2D HomMat3dProject(double principalPointRow, double principalPointCol, double focus)
		{
			IntPtr proc = HalconAPI.PreCall(254);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, principalPointRow);
			HalconAPI.StoreD(proc, 2, principalPointCol);
			HalconAPI.StoreD(proc, 3, focus);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a homogeneous 3D point using a 3x4 projection matrix.
		///   Instance represents: 3x4 projection matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="pw">Input point (w coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qw">Output point (w coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x0600065D RID: 1629 RVA: 0x00025E80 File Offset: 0x00024080
		public HTuple ProjectHomPointHomMat3d(HTuple px, HTuple py, HTuple pz, HTuple pw, out HTuple qy, out HTuple qw)
		{
			IntPtr proc = HalconAPI.PreCall(1930);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pz);
			HalconAPI.Store(proc, 4, pw);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HalconAPI.UnpinTuple(pw);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out qw);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a homogeneous 3D point using a 3x4 projection matrix.
		///   Instance represents: 3x4 projection matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="pw">Input point (w coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <param name="qw">Output point (w coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x0600065E RID: 1630 RVA: 0x00025F34 File Offset: 0x00024134
		public double ProjectHomPointHomMat3d(double px, double py, double pz, double pw, out double qy, out double qw)
		{
			IntPtr proc = HalconAPI.PreCall(1930);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, pz);
			HalconAPI.StoreD(proc, 4, pw);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			num = HalconAPI.LoadD(proc, 2, num, out qw);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a 3D point using a 3x4 projection matrix.
		///   Instance represents: 3x4 projection matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x0600065F RID: 1631 RVA: 0x00025FCC File Offset: 0x000241CC
		public HTuple ProjectPointHomMat3d(HTuple px, HTuple py, HTuple pz, out HTuple qy)
		{
			IntPtr proc = HalconAPI.PreCall(1931);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, px);
			HalconAPI.Store(proc, 2, py);
			HalconAPI.Store(proc, 3, pz);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HalconAPI.UnpinTuple(px);
			HalconAPI.UnpinTuple(py);
			HalconAPI.UnpinTuple(pz);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out qy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project a 3D point using a 3x4 projection matrix.
		///   Instance represents: 3x4 projection matrix.
		/// </summary>
		/// <param name="px">Input point (x coordinate).</param>
		/// <param name="py">Input point (y coordinate).</param>
		/// <param name="pz">Input point (z coordinate).</param>
		/// <param name="qy">Output point (y coordinate).</param>
		/// <returns>Output point (x coordinate).</returns>
		// Token: 0x06000660 RID: 1632 RVA: 0x0002605C File Offset: 0x0002425C
		public double ProjectPointHomMat3d(double px, double py, double pz, out double qy)
		{
			IntPtr proc = HalconAPI.PreCall(1931);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, px);
			HalconAPI.StoreD(proc, 2, py);
			HalconAPI.StoreD(proc, 3, pz);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out qy);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Convert a homogeneous transformation matrix into a 3D pose.
		///   Instance represents: Homogeneous transformation matrix.
		/// </summary>
		/// <returns>Equivalent 3D pose.</returns>
		// Token: 0x06000661 RID: 1633 RVA: 0x000260D8 File Offset: 0x000242D8
		public HPose HomMat3dToPose()
		{
			IntPtr proc = HalconAPI.PreCall(1934);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			base.UnpinTuple();
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		// Token: 0x0400088F RID: 2191
		private const int FIXEDSIZE = 12;
	}
}
